<?xml version="1.0"?>

<st-source>
<time-stamp>From VisualWorks® NonCommercial, 7.6 of March 3, 2008 on June 24, 2009 at 9:06:17 pm</time-stamp>
<!-- Package (none)* -->


<component-property>
<name>(none)</name> <type>package</type>
<property>comment</property> <value>'This "package" is a special package that holds all code (classes, methods, shares, namespaces) that does not show up in a normal package. It is generated automatically. Removing it will remove the code contained in it, but the package itself never goes away. It can serve as a temporary "scratch space" to try quick throw away work before creating a normal package.'</value>
</component-property>

<class>
<name>BackupCell</name>
<environment>Smalltalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>value hist </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category></category>
<attributes>
<package>(none)</package>
</attributes>
</class>

<class>
<name>SpectObjectWrapper</name>
<environment>Smalltalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>dicOld scheduler </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category></category>
<attributes>
<package>(none)</package>
</attributes>
</class>

<class>
<name>PrePostScheduler</name>
<environment>Smalltalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>object </inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category></category>
<attributes>
<package>(none)</package>
</attributes>
</class>

<class>
<name>Reloj</name>
<environment>Smalltalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars>hora min seg dia </inst-vars>
<class-inst-vars>dia </class-inst-vars>
<imports></imports>
<category></category>
<attributes>
<package>(none)</package>
</attributes>
</class>

<class>
<name>NeneDePrimaria</name>
<environment>Smalltalk</environment>
<super>Core.Object</super>
<private>false</private>
<indexed-type>none</indexed-type>
<inst-vars></inst-vars>
<class-inst-vars></class-inst-vars>
<imports></imports>
<category></category>
<attributes>
<package>(none)</package>
</attributes>
</class>






<methods>
<class-id>PrePostScheduler class</class-id> <category>instance creation</category>

<body package="(none)" selector="new:">new: obj

	^super new initialize: obj</body>
</methods>


<methods>
<class-id>PrePostScheduler</class-id> <category>accessing</category>

<body package="(none)" selector="getState">getState
	"Devuelve el estado del objeto encapsulado."
	|i max vars dicc|
	i := 1.
	vars := (object class) allInstVarNames.
	max := vars size.                                        "Mediante el arreglo de variables de instacia y los valores de las mismas en el" 												"objeto"
	dicc := Dictionary new.					     "encapsulado voy armando un diccionario con clave = nombre de variable y "
											     " valor = valor de la variable en ese momento."
	[i &lt;= max] whileTrue: [dicc add: (Core.Association key: ((vars at: i) asSymbol) value: (object instVarAt: i)). i := i + 1]. 

	^ dicc</body>

<body package="(none)" selector="object">object
	
	^object</body>

<body package="(none)" selector="object:">object: anObject
	
	object := anObject</body>
</methods>

<methods>
<class-id>PrePostScheduler</class-id> <category>controlling</category>

<body package="(none)" selector="checkMessage:">checkMessage: selector
	"Chequea si el el objeto encapsulado conoce e mensaje."
	
	^ object respondsTo: selector</body>

<body package="(none)" selector="execute:arg:">execute: selector arg: arguments
	"El objeto encapsulado ejecuta el mensaje original que se le pasa al Wrapper."

	^ object perform: selector withArguments: arguments.</body>

<body package="(none)" selector="checkPrecondition:arg:">checkPrecondition: selector arg: arguments
	"Ejecuta la precondición si el objeto encapsulado la tiene, en caso contrario devuelve true como si se cumpliera siempre."

	|message name|
	name := selector asString.
	name at:1put:((name at:1) asUppercase). 	"Luego del before la primera letra del mensaje original debe ir en mayúscula." 
	message := 'before' , name.
	(object respondsTo: (message asSymbol)) ifFalse: [^ true]
											   ifTrue: [^ object perform: (message asSymbol) withArguments: arguments]</body>

<body package="(none)" selector="checkPostCondition:arg:result:oldDic:">checkPostCondition: selector arg: arguments result: res oldDic: old 
"Este método ejecuta la postcondición si el objeto posse una y si no retorna true como si no tuvise."

	|message name end arrayOld arrayRes arg|					"Declaración las variables que necesito utilizar."
	((arguments size) = 0) ifTrue: [end := 'WithResult:on:']			"Conformación de la parte final del mensaje de acuerdo"
			  		 	  ifFalse: [end := 'withResult:on:'].		"a si tiene o no argumentos."
	name := selector asString.				
	name at:1put:((name at:1) asUppercase).						"La primer letra del mensaje a ejecutar debe estar en mayúscula" 
	message := 'after' , name , end.								"luego del after, a continuación se arma el mensaje completo."
	arrayRes := Array with: res. 
	arrayOld := Array with: old.
	arg := arguments , arrayRes, arrayOld.						"Se agrega a los argumentos la respuesta y el diccionario de" 																"estado."
	(object respondsTo: (message asSymbol)) ifFalse: [^ true]
											   ifTrue: [^ object perform: (message asSymbol) withArguments: arg]

	"Finalmente si el método tiene poscondición se la ejecuta, sino se devuelve true,"
	"como si la postcondición siempre se cumpliera."</body>
</methods>

<methods>
<class-id>PrePostScheduler</class-id> <category>initialize-release</category>

<body package="(none)" selector="initialize:">initialize: obj
	"Inicialización del scheduler asignando al objeto pasado como argumento."	
	
	object := obj.

	^self</body>
</methods>


<methods>
<class-id>BackupCell class</class-id> <category>instance creation</category>

<body package="(none)" selector="new">new

	^super new initialize</body>
</methods>


<methods>
<class-id>BackupCell</class-id> <category>PreConditions</category>

<body package="(none)" selector="beforeRestore">beforeRestore
	"Verifica que no esté el historial vacío."
	
	^(hist = nil) not</body>
</methods>

<methods>
<class-id>BackupCell</class-id> <category>method</category>

<body package="(none)" selector="restore">restore
	"Restaura el valor almacenado en el historial, elimina dicho historial y retorna el objeto receptor."
	
	value := hist.
	hist := nil.
	
	^self.</body>
</methods>

<methods>
<class-id>BackupCell</class-id> <category>accessing</category>

<body package="(none)" selector="value">value
	"Retorna el valor actual."

	^value</body>

<body package="(none)" selector="value:">value: aValue
	"Asigna un nuevo valor a la celda guardando el anterior en el historial, devuelve el objeto receptor."	

	hist := value.
	value := aValue.

	^ self</body>
</methods>

<methods>
<class-id>BackupCell</class-id> <category>PostConditions</category>

<body package="(none)" selector="afterValue:withResult:on:">afterValue: aValue withResult: res on: old
	"Se debe retornar el objeto receptor y además haber modificado de manera correcta"	
	
	^ (hist = (old at: #value)) &amp; (self == res)</body>

<body package="(none)" selector="afterRestoreWithResult:on:">afterRestoreWithResult: res on: old
	"Se debe retornar el objeto receptor y además haber restaurado de manera correcta"	
	
	^ (value = (old at: #hist)) &amp;  (hist = nil) &amp; (self == res)</body>

<body package="(none)" selector="afterValueWithResult:on:">afterValueWithResult: res on: old
	"Se debe retornar el objeto receptor y además haber modificado de manera correcta"	
	
	^ (value = res).</body>
</methods>

<methods>
<class-id>BackupCell</class-id> <category>initialize-release</category>

<body package="(none)" selector="initialize">initialize
	
	^self</body>
</methods>


<methods>
<class-id>SpectObjectWrapper class</class-id> <category>instance creation</category>

<body package="(none)" selector="wrap:">wrap: obj
	
     ^super new initialize: obj</body>
</methods>


<methods>
<class-id>SpectObjectWrapper</class-id> <category>accessing</category>

<body package="(none)" selector="dicOld">dicOld
	
	^dicOld</body>

<body package="(none)" selector="dicOld:">dicOld: anObject
	
	dicOld := anObject</body>
</methods>

<methods>
<class-id>SpectObjectWrapper</class-id> <category>error handling</category>

<body package="(none)" selector="doesNotUnderstand:">doesNotUnderstand: msg
	|sel args res|

	sel := msg selector.
	args := msg arguments.		"Se descompone el mensaje en el selector y los argumentos."			

	"Se verifica si el onjeto conoce dicho mensaje."
	(scheduler checkMessage: sel) ifFalse: [^ (Error new) errorString: 'El objeto no responde a ese mensaje'; raise].

	"Se chequea la precondición del mensaje para el objeto."
	(scheduler checkPrecondition: sel arg:args) ifFalse: [^ (Error new) errorString: 'No se cumple la precondicion del mensaje'; raise].

	"Se obtiene el estado del objeto antes de ejecutar el mensaje."
	dicOld := scheduler getState.

	"Se ejecuta el mensaje para el objeto encapsulado."
	res := scheduler execute: sel arg: args.

	"Se corrobora la postcondición."
	(scheduler checkPostCondition: sel arg:args result: res oldDic: dicOld) ifFalse: [^ (Error new) errorString: 'No se cumple la 	postcondicion del mensaje'; raise].

	"Se retorna el valor devuelto por el mensaje al objeto encapsulado si se cumplieron la pre y post condición."
	"Y en caso de que el mensaje devuelva al objeto lo que devuelvo es el mismo wrapper"
	(res == scheduler object)  ifTrue: [^self].

	^res</body>
</methods>

<methods>
<class-id>SpectObjectWrapper</class-id> <category>initialize-release</category>

<body package="(none)" selector="initialize:">initialize: obj
	"Inicializo el encapsulador con el scheduler de pre y pos condiciones." 	

	scheduler := PrePostScheduler new:obj.         	
 
	^self</body>
</methods>


<methods>
<class-id>NeneDePrimaria class</class-id> <category>instance creation</category>

<body package="(none)" selector="new">new
	"Answer a newly created and initialized instance."

	^super new initialize</body>
</methods>


<methods>
<class-id>NeneDePrimaria</class-id> <category>posConditions</category>

<body package="(none)" selector="afterHacerMal:mas:withResult:on:">afterHacerMal: x mas: y withResult: res on: old
	"La postcondición no se debería cumplir."

	^ (x + y = res)</body>

<body package="(none)" selector="afterHacer:mas:withResult:on:">afterHacer: x mas: y withResult: res on: old
	"Verifica si la suma es correcta."

	^ (x + y = res)</body>

<body package="(none)" selector="afterJugarConGrassiWithResult:on:">afterJugarConGrassiWithResult: res on: old
	"La postcondición se debería cumplir."

	^ (res = false)</body>
</methods>

<methods>
<class-id>NeneDePrimaria</class-id> <category>preConditions</category>

<body package="(none)" selector="beforeHacerMal:mas:">beforeHacerMal: x mas: y
	"Es la misma verificación que para el mensaje hacer:mas:."

	^ (x &gt; 0) &amp; (y &gt;0).</body>

<body package="(none)" selector="beforeHacer:mas:">beforeHacer: x mas: y
	"Verifico si los argumentos son mayores a 0."

	^ (x &gt; 0) &amp; (y &gt;0).</body>
</methods>

<methods>
<class-id>NeneDePrimaria</class-id> <category>methods</category>

<body package="(none)" selector="hacerMal:mas:">hacerMal: x mas: y
	"Tiene las mismas pre y post de hacer, es para verificar que no se cumple con la postcondición."

	^ x + y + x.</body>

<body package="(none)" selector="hacer:mas:">hacer: x mas: y
	"Realiza una suma simple de los argumentos."

	^ x + y.</body>

<body package="(none)" selector="gritar">gritar
	"Este método no tiene ni pre ni postcondición, servirá para probar que igual finaliza."

	Transcript show: 'Ahhhhhhhh!!'.
	
	^ nil</body>

<body package="(none)" selector="jugarConGrassi">jugarConGrassi
	"Este método es para probar que sólo existe postcondición e igual se ejecuta de manera correcta."

	Transcript show: 'Este safo del degenerado ese'.
	
	^ false</body>
</methods>

<methods>
<class-id>NeneDePrimaria</class-id> <category>initialize-release</category>

<body package="(none)" selector="initialize">initialize
	"Initialize a newly created instance. This method must answer the receiver."

	" *** Replace this comment with the appropriate initialization code *** "
	^self</body>
</methods>


<methods>
<class-id>Reloj class</class-id> <category>instance creation</category>

<body package="(none)" selector="new:min:seg:">new:hora min:min seg:seg
	"Answer a newly created and initialized instance."

	^super new initialize:hora min:min seg:seg</body>

<body package="(none)" selector="new">new
	"Answer a newly created and initialized instance."

	^super new initialize</body>
</methods>


<methods>
<class-id>Reloj</class-id> <category>initialize-release</category>

<body package="(none)" selector="initialize">initialize
	"Initialize a newly created instance. This method must answer the receiver."

	" *** Replace this comment with the appropriate initialization code *** "
	^self</body>

<body package="(none)" selector="initialize:min:seg:">initialize: h min: m seg: s
	"Esta clase servirá para probar el correcto funcionamiento del diccionario de estado en el encapsulador."

	hora := h.
	min := m.
	seg := s.
	dia := 0.

	^self</body>
</methods>

<methods>
<class-id>Reloj</class-id> <category>methods</category>

<body package="(none)" selector="pasarDia">pasarDia

	dia := dia + 1.

	^dia.</body>
</methods>

<methods>
<class-id>Reloj</class-id> <category>postCondition</category>

<body package="(none)" selector="afterPasarDiaWithResult:on:">afterPasarDiaWithResult: res on: old
	"La postcondición será cierta si solo se modifica el valor de día y el resto permanece constante."

	^(dia = ((old at: #dia) + 1)) &amp; (hora = (old at: #hora)) &amp; (min = (old at: #min)) &amp; (seg = (old at: #seg))</body>
</methods>



</st-source>
